home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1996 / MacHack 1996.toast / Hacks / Hacks ’89 / gadlife / source (ugly) / scrap.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-05-14  |  4.7 KB  |  211 lines  |  [TEXT/KAHL]
  1. #include "main.h"
  2.  
  3. extern int            isBackground;
  4.  
  5. static BitMap        myClipBits;
  6. static RgnHandle    myClipRgn;
  7. static int            clipChanged = 0,
  8.                 isClip = 0,
  9.                 couldClip = 0,
  10.                 scrapCount,
  11.                 needsImport = -1;
  12.  
  13. int couldPaste()
  14. {
  15.     return( isClip || ( couldClip && needsImport ));
  16. }
  17.  
  18. clearMyClip()
  19. {
  20.     if( isClip ) {
  21.         DisposPtr( myClipBits.baseAddr );
  22.         SetEmptyRgn( myClipRgn );
  23.         isClip = 0;
  24.         ++clipChanged;
  25.     }
  26. }
  27.  
  28. setMyClip( source, maskRgn )
  29.     BitMap        *source;
  30.     RgnHandle        maskRgn;
  31. {
  32.     clearMyClip();
  33.     myClipBits = *source;
  34.     ptrToPtr( &( myClipBits.baseAddr ));
  35.     CopyRgn( maskRgn, myClipRgn );
  36.     isClip = -1;
  37.     needsImport = 0;
  38.     ++clipChanged;
  39. }
  40.  
  41. pasteClip( dest, maskRgn, force, dRect )
  42.     BitMap        *dest;
  43.     RgnHandle        maskRgn;
  44.     Rect            *dRect;
  45. {
  46.     Rect            sBounds, bounds;
  47.     int            dh, dv, result = 0;
  48.     
  49.     if( needsImport ) importScrap();
  50.     if( isClip ) {
  51.         if( force && rgnIsRect( maskRgn, &( dest->bounds ))) {
  52.             CopyBig( &myClipBits, dest, &( myClipBits.bounds ), &( dest->bounds ), srcCopy, NULL );
  53.             CopyRgn( myClipRgn, maskRgn );
  54.             MapRgn( maskRgn, &( myClipBits.bounds ), &( dest->bounds ));
  55.         } else {
  56.             if( force ) DisposPtr( *dest->baseAddr );
  57.             bounds = myClipBits.bounds;
  58.             dh = ( dRect->right + dRect->left - bounds.right - bounds.left ) / 2;
  59.             dv = ( dRect->bottom + dRect->top - bounds.bottom - bounds.top ) / 2;
  60.             OffsetRect( &bounds, dh, dv );
  61.             SectRect( &bounds, dRect, &bounds );
  62.             sBounds = bounds;
  63.             OffsetRect( &sBounds, -dh, -dv );
  64.             setRectBits( dest, &bounds );
  65.             CopyBig( &myClipBits, dest, &sBounds, &bounds, srcCopy, NULL );
  66.             RectRgn( maskRgn, &sBounds );
  67.             SectRgn( myClipRgn, maskRgn, maskRgn );
  68.             OffsetRgn( maskRgn, dh, dv );
  69.         }
  70.         result = -1;
  71.     }
  72.     return( result );
  73. }
  74.  
  75. initScrap()
  76. {
  77.     myClipRgn = NewRgn();
  78.     scrapCount = InfoScrap()->scrapCount - 1;
  79.     setBadScrap();
  80. }
  81.  
  82. setBadScrap()
  83. {
  84.     long    offset;
  85.     int    newCount;
  86.     
  87.     newCount = InfoScrap()->scrapCount;
  88.     if( newCount != scrapCount ) {
  89.         if( !needsImport ) {
  90.             clearMyClip();
  91.             clipChanged = 0;
  92.             needsImport = -1;
  93.         }
  94.         scrapCount = newCount;
  95.         couldClip = GetScrap( NULL, 'PICT', &offset ) >= 0;
  96.     }
  97. }
  98.  
  99. makeTempPort( tempBits, tempPort )
  100.     BitMap        *tempBits;
  101.     GrafPtr        tempPort;
  102. {
  103.     OpenPort( tempPort );
  104.     SetPortBits( tempBits );
  105.     PortSize( tempBits->bounds.right - tempBits->bounds.left, tempBits->bounds.bottom - tempBits->bounds.top );
  106.     MovePortTo( 0, 0 );
  107.     SetOrigin( tempBits->bounds.left, tempBits->bounds.top );
  108.     RectRgn( tempPort->visRgn, &tempBits->bounds );
  109.     CopyRgn( tempPort->visRgn, tempPort->clipRgn );
  110. }
  111.  
  112. importScrap()
  113. {
  114.     GrafPort        tempPort;
  115.     Rect            *bounds;
  116.     PicHandle        theScrap;
  117.     GrafPtr        savePort;
  118.     long            offset, errno;
  119.     
  120.     clearMyClip();
  121.     if( couldClip ) {
  122.         theScrap = ( PicHandle )NewHandle( 0L );
  123.         errno = GetScrap( theScrap, 'PICT', &offset );
  124.         if( errno >= 0 ) {
  125.             bounds = &( **theScrap ).picFrame;
  126.             setRectBits( &myClipBits, bounds );
  127.             RectRgn( myClipRgn, bounds );
  128.             GetPort( &savePort );
  129.             makeTempPort( &myClipBits, &tempPort );
  130.             DrawPicture( theScrap, bounds );
  131.             SetPort( savePort );
  132.             ClosePort( &tempPort );
  133.             isClip = -1;
  134.         } else if( errno != noTypeErr ) softPanic( errno, scrapPanic );
  135.         DisposHandle( theScrap );
  136.         clipChanged = 0;
  137.         needsImport = 0;
  138.         scrapCount = InfoScrap()->scrapCount;
  139.     }
  140. }
  141.  
  142. exportScrap()
  143. {
  144.     GrafPort        tempPort;
  145.     BitMap        tempBits;
  146.     PicHandle        thePict;
  147.     GrafPtr        savePort;
  148.     Rect            *bounds;
  149.     long            length;
  150.     
  151.     if( clipChanged ) ZeroScrap();
  152.     if( isClip && clipChanged ) {
  153.         GetPort( &savePort );
  154.         makeTempPort( &myClipBits, &tempPort );
  155.         tempBits.rowBytes = 0;
  156.         tempBits.bounds.top = tempBits.bounds.left = 0;
  157.         tempBits.bounds.bottom = tempBits.bounds.right = 0;
  158.         tempBits.baseAddr = NewPtr( 0L );
  159.         SetPortBits( &tempBits );
  160.         bounds = &myClipBits.bounds;
  161.         thePict = OpenPicture( bounds );
  162.         CopyBig( &myClipBits, &tempBits, bounds, bounds, srcCopy, myClipRgn );
  163.         ClosePicture();
  164.         length = GetHandleSize( thePict );
  165.         HLock( thePict );
  166.         PutScrap( length, 'PICT', *thePict );
  167.         KillPicture( thePict );
  168.         SetPort( savePort );
  169.         ClosePort( &tempPort );
  170.         DisposPtr( tempBits.baseAddr );
  171.     }
  172.     clipChanged = 0;
  173.     needsImport = 0;
  174.     scrapCount = InfoScrap()->scrapCount;
  175. }
  176.  
  177.  
  178. doEdClear( theData )
  179.     dataPtr    theData;
  180. {
  181.     int        needsDraw = 0;
  182.     
  183.     if( theData->isSelect ) {
  184.         if( theData->selActive ) --isBackground;
  185.         theData->isSelect = 0;
  186.         theData->selActive = 0;
  187.         DisposPtr( theData->selBits.baseAddr );
  188.         SetEmptyRgn( theData->selRgn );
  189.         needsDraw = bitsBadData;
  190.     }
  191.     return( needsDraw );
  192. }
  193.  
  194. doEdPaste( theData )
  195.     dataPtr    theData;
  196. {
  197.     int        needsDraw = 0;
  198.     
  199.     if( couldPaste() && pasteClip( &( theData->selBits ), theData->selRgn, theData->isSelect, &( theData->dataRect ))) {
  200.         if( !theData->isSelect ) {
  201.             ++isBackground;
  202.             theData->isSelect = -1;
  203.             theData->selActive = -1;
  204.             needsDraw |= bitsBadAnts;
  205.         }
  206.         needsDraw |= bitsBadSel;
  207.     }
  208.     return( needsDraw );
  209. }
  210.  
  211.